package com.gxa.mobile.service.impl;

import com.alibaba.dubbo.config.annotation.Reference;
import com.gxa.service.GoodsRpcVo;
import com.gxa.core.result.Result;
import com.gxa.core.result.ResultUtils;
import com.gxa.mobile.pojo.vo.GoodsVo;
import com.gxa.mobile.pojo.vo.TCartVo;
import com.gxa.mobile.utils.PublicData;
import com.gxa.service.GoodsRpcService;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import com.gxa.mobile.service.ShoppingCarService;
import java.math.BigDecimal;
import java.util.*;

/**
 * <h3>coffee</h3>
 * <p></p>
 *
 * @author : ch
 * @date : 2024-03-22 15:10
 **/
//@Service
@Slf4j
public class ShoppingCarServiceImpl implements ShoppingCarService {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private Redisson redisson;

    //dubbo远程调用
    @Reference
    private GoodsRpcService goodsRpcService;

//    private ShoppingCarMapper shoppingCarMapper;

    @Override
    public List<GoodsRpcVo> selectAllCart(Integer userId) {
//        List<GoodsRpcVo> goodsRpcVos = new ArrayList<>();
//        // 根据userId获取购物车
//        TCartVo tCartVo = this.selectCart(userId);
//        // 遍历商品列表
//        List<GoodsVo> goodsVoList = Optional.ofNullable(tCartVo).map(TCartVo::getGoodsVo).orElse(Collections.emptyList());
//        for (GoodsVo goodVo : goodsVoList) {
//            // 取出每件商品的id
//            Integer goodsId = goodVo.getGoodsId();
//            if (goodsId == null) {
//                // 处理商品ID为null的情况，例如记录日志或跳过当前循环
//                continue;
//            }
//            try {
//                // 根据商品id查询商品信息
//                GoodsRpcVo tGoods = goodsRpcService.findGoodsById(String.valueOf(goodsId));
//                if (tGoods != null) {
//                    BigDecimal price = tGoods.getGoodsPrice();
//                    BigDecimal number = BigDecimal.valueOf(goodVo.getNumber());
//                    BigDecimal totalPrice = price.multiply(number);
//                    tGoods.setCount(goodVo.getNumber());
//                    tGoods.setTotalPrice(totalPrice);
//                    goodsRpcVos.add(tGoods);
//                } else {
//                    // 处理查询商品信息为null的情况，例如记录日志或跳过当前循环
//                    // 可能的操作取决于业务逻辑
//                }
//            } catch (Exception e) {
////                log.error("Error fetching goods information for ID: " + goodsId, e);
//            }
//        }
        return null;
    }

    @Override
    public List<GoodsRpcVo> selectCart(String userId) {

        String itemName = PublicData.SHOPPINGCART_REDISGOODNAME + userId;

        TCartVo itemValue = (TCartVo) redisTemplate.opsForValue().get(itemName);

        if (itemValue != null) {

//            System.out.println(redisTemplate.opsForValue().get(itemName)+"select");

            return null;

        } else {
            //为该用户创建新的购物车
            TCartVo tCartVo = new TCartVo();
//            tCartVo.setUserId(userId);
            tCartVo.setCreated(new Date());

            redisTemplate.opsForValue().set(itemName, tCartVo);

//            System.out.println(redisTemplate.opsForValue().get(itemName)+"selectadd");

            return null;
        }
    }

    @Override
    public TCartVo addCarts(Integer userId, Integer goodsId, Integer number) {
        String itemName = PublicData.SHOPPINGCART_REDISGOODNAME + userId;


        RLock lock = redisson.getLock("cartLock"+userId);
        try {
            //加锁
            lock.lock();
        TCartVo tCartVo = (TCartVo) redisTemplate.opsForValue().get(itemName);
            if (tCartVo == null) {
                tCartVo = new TCartVo();
                tCartVo.setUserId(userId);
                tCartVo.setGoodsVo(new ArrayList<>());
            }
            // 创建一个新的GoodsVo对象，设置商品的ID和数量
        GoodsVo newGoodsVo = new GoodsVo();
        newGoodsVo.setGoodsId(goodsId);
        newGoodsVo.setNumber(number);
        // 确保购物车对象的商品列表不为null
        List<GoodsVo> goodsVos = tCartVo.getGoodsVo();
        if (goodsVos == null) {
            goodsVos = new ArrayList<>();
        }
        // 检查购物车中是否已存在具有相同商品ID的商品
        boolean exists = false;
        for (GoodsVo existingGoodsVo : goodsVos) {
            if (existingGoodsVo.getGoodsId().equals(newGoodsVo.getGoodsId())) {
                // 如果已存在，可以选择更新数量或执行其他逻辑
                // 例如，增加数量
                existingGoodsVo.setNumber(existingGoodsVo.getNumber() + newGoodsVo.getNumber());
                exists = true;
                break; // 找到后退出循环
            }
        }
        // 如果商品不存在于购物车中，则添加新商品
        if (!exists) {
            goodsVos.add(newGoodsVo);
        }
        // 更新购物车对象的商品列表
        tCartVo.setGoodsVo(goodsVos);

        // 将更新后的购物车对象存储到Redis中
        redisTemplate.opsForValue().set(itemName, tCartVo);

        return (TCartVo) redisTemplate.opsForValue().get(itemName);
        }catch (Exception e){
            // 处理异常，例如记录日志、返回错误信息给调用者等
            log.error("Error adding item to cart for user " + userId, e);
            // 根据业务需求决定是返回null、空购物车对象还是抛出异常
            return null;
        }
        finally {
            // 释放锁
            lock.unlock();

        }
    }

    //清空购物车
    @Override
    public boolean deleteUserCart(Integer userId) {

        String itemName = PublicData.SHOPPINGCART_REDISGOODNAME+ userId;

        return redisTemplate.delete(itemName);

    }
    //购物车结算所有商品
    @Override
    public Result<List<GoodsRpcVo>> buyShoppingAllCart(Integer userId) {

        //redis加锁，防止缓存雪崩
        RLock lock = redisson.getLock("userId"+userId);
        try {
            //加锁
            lock.lock();
        // 获取购物车中的所有商品
        List<GoodsRpcVo> goodsRpcVos=this.selectAllCart(userId);

        if (goodsRpcVos == null || goodsRpcVos.isEmpty()) {
            // 购物车为空，无需处理
            return ResultUtils.buildFail("无任何需要结算商品");
        }

        // 这里添加结算逻辑，例如创建订单，减少库存等

        // 清空购物车
        deleteUserCart(userId);
        // 返回是否结算成功
        return ResultUtils.buildSuccess(goodsRpcVos);
    } finally {
        lock.unlock(); // 释放锁
    }
}

    //给购物车删除商品
    @Override
    public boolean deleteCart(Integer userId, Integer goodsId) {
        String itemName = PublicData.SHOPPINGCART_REDISGOODNAME + userId;
        TCartVo tCartVo = (TCartVo) redisTemplate.opsForValue().get(itemName);
        System.out.println(tCartVo);
        if (tCartVo == null) {
            // 购物车为空，无法删除商品
            return false;
        }
        List<GoodsVo> goodsVos = tCartVo.getGoodsVo();
        if (goodsVos != null) {
            // 移除具有指定商品ID的商品
            goodsVos.removeIf(goodsVo -> goodsVo.getGoodsId().equals(goodsId));
            // 如果移除后购物车为空，可以考虑是否删除整个购物车记录，这取决于业务需求
            if (goodsVos.isEmpty()) {
                // 可以选择清空购物车或删除整个购物车记录
                this.deleteUserCart(userId);
            } else {
                // 更新购物车中的商品列表
                tCartVo.setGoodsVo(goodsVos);

                // 将更新后的购物车对象存储回Redis
                redisTemplate.opsForValue().set(itemName, tCartVo);
            }
        }

        // 返回是否成功删除商品
        return true;
    }

    //购物车结算部分商品
    @Override
    public Result<GoodsRpcVo> buyShoppingCart(Integer userId,Integer goodsId) {

        //redis加锁，防止缓存雪崩
        RLock lock = redisson.getLock("userId"+userId);
        try {
            //加锁
            lock.lock();
        // 获取购物车中的所有商品
        List<GoodsRpcVo> goodsRpcVos = this.selectAllCart(userId);

        if (goodsRpcVos == null || goodsRpcVos.isEmpty()) {
            // 购物车为空，无需处理
            return ResultUtils.buildFail("购物车为空，无法结算");
        }

        GoodsRpcVo toBuyGoods = null;
        for (GoodsRpcVo goodsRpcVo : goodsRpcVos) {

            if (goodsId.equals(goodsRpcVo.getGoodsId())) {

                toBuyGoods = goodsRpcVo;

                break; // 假设我们只处理第一个匹配的商品
            }
        }

        if (toBuyGoods == null) {
            // 未找到要结算的商品
            return ResultUtils.buildFail("未找到要结算的商品");
        }

        try {
            // 执行结算逻辑，例如检查库存、创建订单等
//            if (!checkStock(toBuyGoods.getGoodsId(), toBuyGoods.getNumber())) {
//                return ResultUtils.buildFail("库存不足，无法结算");
//            }
//
//            Order order = createOrder(userId, toBuyGoods);
//            if (order == null) {
//                return ResultUtils.buildFail("订单创建失败");
//            }

            // 更新库存（这里应该是调用库存服务的方法）


            // 从购物车中删除已结算的商品
            deleteCart(userId, goodsId);

            return ResultUtils.buildSuccess(toBuyGoods);
        } catch (Exception e) {
            // 异常处理
            return ResultUtils.buildFail("结算商品时发生异常：" + e.getMessage());
        }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    @Override
    public boolean addItem(Integer userId, Integer goodsId, Integer number) {
        return false;
    }

    //减少商品数量
    @Override
    public boolean reduceCartItemQuantity(Integer userId, Integer goodsId, Integer quantity) {
        String itemName = PublicData.SHOPPINGCART_REDISGOODNAME + userId;
        TCartVo tCartVo = (TCartVo) redisTemplate.opsForValue().get(itemName);

        if (tCartVo == null) {
            // 购物车为空，无法减少商品数量
            return false;
        }

        List<GoodsVo> goodsVos = tCartVo.getGoodsVo();
        if (goodsVos != null) {
            // 遍历购物车中的商品，查找并减少指定商品的数量
            for (GoodsVo goodsVo : goodsVos) {
                if (goodsVo.getGoodsId().equals(goodsId)) {
                    int currentQuantity = goodsVo.getNumber();
                    int newQuantity = currentQuantity + quantity;

                    // 检查减少后的数量是否有效
                    if (newQuantity >= 0) {
                        // 更新商品数量
                        goodsVo.setNumber(newQuantity);

                        // 如果数量减少到0，则从购物车中移除该商品
                        if (newQuantity == 0) {
                            goodsVos.remove(goodsVo);
                        }

                        // 更新购物车对象
                        tCartVo.setGoodsVo(goodsVos);

                        // 将更新后的购物车对象存储回Redis
                        redisTemplate.opsForValue().set(itemName, tCartVo);

                        return true; // 成功减少数量
                    } else {
                        // 尝试减少的数量超过了当前数量，无法执行
                        return false;
                    }
                }
            }
        }

        // 如果没有找到指定商品ID的商品，无法减少数量
        return false;
    }

    //更新商品数量
    @Override
    public boolean updateCart(Integer userId, Integer goodsId, Integer number) {

        String itemName = PublicData.SHOPPINGCART_REDISGOODNAME + userId;
        TCartVo tCartVo = (TCartVo) redisTemplate.opsForValue().get(itemName);

        if (tCartVo == null) {
            // 购物车为空，没有商品可以修改数量
            return false;
        }
        List<GoodsVo> goodsVos = tCartVo.getGoodsVo();

        if (goodsVos != null) {
            // 遍历购物车中的商品，查找并减少指定商品的数量
            for (GoodsVo goodsVo : goodsVos) {
                if (goodsVo.getGoodsId().equals(goodsId)) {
                    int currentQuantity = goodsVo.getNumber();

                    // 检查减少后的数量是否有效
                    if (number >= 0) {
                        // 更新商品数量
                        goodsVo.setNumber(number);

                        // 如果数量减少到0，则从购物车中移除该商品
                        if (number == 0) {
                            goodsVos.remove(goodsVo);
                        }
                        // 更新购物车对象
                        tCartVo.setGoodsVo(goodsVos);

                        // 将更新后的购物车对象存储回Redis
                        redisTemplate.opsForValue().set(itemName, tCartVo);

                        return true; // 成功减少数量
                    } else {
                        // 尝试减少的数量超过了当前数量，无法执行
                        return false;
                    }
                }
            }
        }

        // 如果没有找到指定商品ID的商品，无法减少数量
        return false;

    }


}
